home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_pyclbr.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  6KB  |  194 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. '''
  5.    Test cases for pyclbr.py
  6.    Nick Mathewson
  7. '''
  8. from test.test_support import run_unittest
  9. import unittest
  10. import sys
  11. from types import ClassType, FunctionType, MethodType, BuiltinFunctionType
  12. import pyclbr
  13. from unittest import TestCase
  14. StaticMethodType = type(staticmethod((lambda : pass)))
  15. ClassMethodType = type(classmethod((lambda c: pass)))
  16. from commands import getstatus
  17.  
  18. class PyclbrTest(TestCase):
  19.     
  20.     def assertListEq(self, l1, l2, ignore):
  21.         ''' succeed iff {l1} - {ignore} == {l2} - {ignore} '''
  22.         missing = (set(l1) ^ set(l2)) - set(ignore)
  23.         if missing:
  24.             print >>sys.stderr, 'l1=%r\nl2=%r\nignore=%r' % (l1, l2, ignore)
  25.             self.fail('%r missing' % missing.pop())
  26.         
  27.  
  28.     
  29.     def assertHasattr(self, obj, attr, ignore):
  30.         ''' succeed iff hasattr(obj,attr) or attr in ignore. '''
  31.         if attr in ignore:
  32.             return None
  33.         
  34.         if not hasattr(obj, attr):
  35.             print '???', attr
  36.         
  37.         self.failUnless(hasattr(obj, attr), 'expected hasattr(%r, %r)' % (obj, attr))
  38.  
  39.     
  40.     def assertHaskey(self, obj, key, ignore):
  41.         ''' succeed iff obj.has_key(key) or key in ignore. '''
  42.         if key in ignore:
  43.             return None
  44.         
  45.         if not obj.has_key(key):
  46.             print >>sys.stderr, '***', key
  47.         
  48.         self.failUnless(obj.has_key(key))
  49.  
  50.     
  51.     def assertEqualsOrIgnored(self, a, b, ignore):
  52.         ''' succeed iff a == b or a in ignore or b in ignore '''
  53.         if a not in ignore and b not in ignore:
  54.             self.assertEquals(a, b)
  55.         
  56.  
  57.     
  58.     def checkModule(self, moduleName, module = None, ignore = ()):
  59.         ''' succeed iff pyclbr.readmodule_ex(modulename) corresponds
  60.             to the actual module object, module.  Any identifiers in
  61.             ignore are ignored.   If no module is provided, the appropriate
  62.             module is loaded with __import__.'''
  63.         if module == None:
  64.             module = __import__(moduleName, globals(), { }, [
  65.                 '<silly>'])
  66.         
  67.         dict = pyclbr.readmodule_ex(moduleName)
  68.         
  69.         def ismethod(oclass, obj, name):
  70.             classdict = oclass.__dict__
  71.             if isinstance(obj, FunctionType):
  72.                 if not isinstance(classdict[name], StaticMethodType):
  73.                     return False
  74.                 
  75.             elif not isinstance(obj, MethodType):
  76.                 return False
  77.             
  78.             if obj.im_self is not None:
  79.                 if not isinstance(classdict[name], ClassMethodType) or obj.im_self is not oclass:
  80.                     return False
  81.                 
  82.             elif not isinstance(classdict[name], FunctionType):
  83.                 return False
  84.             
  85.             objname = obj.__name__
  86.             if objname.startswith('__') and not objname.endswith('__'):
  87.                 objname = '_%s%s' % (obj.im_class.__name__, objname)
  88.             
  89.             return objname == name
  90.  
  91.         for name, value in dict.items():
  92.             if name in ignore:
  93.                 continue
  94.             
  95.             self.assertHasattr(module, name, ignore)
  96.             py_item = getattr(module, name)
  97.             if isinstance(value, pyclbr.Function):
  98.                 self.assert_(isinstance(py_item, (FunctionType, BuiltinFunctionType)))
  99.                 continue
  100.             self.failUnless(isinstance(py_item, (ClassType, type)))
  101.             real_bases = [ base.__name__ for base in py_item.__bases__ ]
  102.             pyclbr_bases = [ getattr(base, 'name', base) for base in value.super ]
  103.             
  104.             try:
  105.                 self.assertListEq(real_bases, pyclbr_bases, ignore)
  106.             except:
  107.                 []
  108.                 []
  109.                 []
  110.                 print >>sys.stderr, 'class=%s' % py_item
  111.                 raise 
  112.  
  113.             actualMethods = []
  114.             for m in py_item.__dict__.keys():
  115.                 if ismethod(py_item, getattr(py_item, m), m):
  116.                     actualMethods.append(m)
  117.                     continue
  118.                 []
  119.             
  120.             foundMethods = []
  121.             for m in value.methods.keys():
  122.                 if m[:2] == '__' and m[-2:] != '__':
  123.                     foundMethods.append('_' + name + m)
  124.                     continue
  125.                 []
  126.                 foundMethods.append(m)
  127.             
  128.             
  129.             try:
  130.                 self.assertListEq(foundMethods, actualMethods, ignore)
  131.                 self.assertEquals(py_item.__module__, value.module)
  132.                 self.assertEqualsOrIgnored(py_item.__name__, value.name, ignore)
  133.             continue
  134.             []
  135.             print >>sys.stderr, 'class=%s' % py_item
  136.             raise 
  137.             continue
  138.  
  139.         
  140.         
  141.         def defined_in(item, module):
  142.             if isinstance(item, ClassType):
  143.                 return item.__module__ == module.__name__
  144.             
  145.             if isinstance(item, FunctionType):
  146.                 return item.func_globals is module.__dict__
  147.             
  148.             return False
  149.  
  150.         for name in dir(module):
  151.             item = getattr(module, name)
  152.             if isinstance(item, (ClassType, FunctionType)):
  153.                 if defined_in(item, module):
  154.                     self.assertHaskey(dict, name, ignore)
  155.                 
  156.             defined_in(item, module)
  157.         
  158.  
  159.     
  160.     def test_easy(self):
  161.         self.checkModule('pyclbr')
  162.         self.checkModule('doctest')
  163.         self.checkModule('rfc822')
  164.         self.checkModule('difflib')
  165.  
  166.     
  167.     def test_decorators(self):
  168.         self.checkModule('test.pyclbr_input')
  169.  
  170.     
  171.     def test_others(self):
  172.         cm = self.checkModule
  173.         cm('random', ignore = ('Random',))
  174.         cm('cgi', ignore = ('log',))
  175.         cm('mhlib')
  176.         cm('urllib', ignore = ('getproxies_registry', 'open_https', 'getproxies_internetconfig'))
  177.         cm('pickle')
  178.         cm('aifc', ignore = ('openfp',))
  179.         cm('Cookie')
  180.         cm('sre_parse', ignore = ('dump',))
  181.         cm('pdb')
  182.         cm('pydoc')
  183.         cm('email.Parser')
  184.         cm('test.test_pyclbr')
  185.  
  186.  
  187.  
  188. def test_main():
  189.     run_unittest(PyclbrTest)
  190.  
  191. if __name__ == '__main__':
  192.     test_main()
  193.  
  194.